//
//  "$Id: VideoIn.h 104652 2013-03-07 07:33:30Z sun_xiaohui $"
//
//  Copyright (c)1992-2007, ZheJiang Dahua Technology Stock CO.LTD.
//  All Rights Reserved.
//
//	Description:	
//	Revisions:		Year-Month-Day  SVN-Author  Modification
//

#ifndef __VIDEO_IN_API_H__
#define __VIDEO_IN_API_H__

#include "Types.h"
#include "Defs.h"

#ifdef __cplusplus
extern "C" {
#endif


/// \defgroup VideoInAPI API Video Input
/// 视频输入接口
///	\n 调用流程图:
/// \code
///    ==========================
///               |                            
///       getVideoInChannels
///               |
///       createVideoInput
///               |
///            addRef
///               |
///          setStandard
///               |
///            getCaps
///               |
///           setFormat
///               |
///          setOptions
///               |
///           setTitle
///               |
///       setBackgroundColor
///               |
///           setColor 
///               |
///           setCover 
///               |
///            layout
///               |
///          setZoomRect
///               |
///         setOutputRect
///               |         
///            release
///               |
///    ===========================
/// \endcode
/// @{

#include "Types.h"
/// 视频表面。视频表面是内存中的一个保留区域，像素数据按一定的像素格式存放;
/// 如果采用多缓冲来保存像素数据，这样其内存区域是不断变化的，需要对应的刷新机制。
///	表面可以驻留在芯片内存或者系统内存中，可以对表面执行转换操作，或者将一个表面
/// 的内容拷贝（包括裁剪和缩放）到另一个表面，所有的操作可以是硬件实现，也可以是
///	软件实现，取决于表面的特性。视频使用统一框架实现回放视频，图形的分割，调制缩放，或者
///	多路复用,然后送到视频输出设备，或者送到预览编码设备。

typedef void VideoSurface;

/// 视频信号格式
typedef enum VideoSignalFormat
{
	videoSignalFormatInside = 0,	///< 内置的信号输入
	videoSignalFormatBT656,			///< BT656标准
	videoSignalFormat720p,			///< 720逐行高清标准
	videoSignalFormat1080i,			///< 1080隔行高清标准
	videoSignalFormat1080p,			///< 1080逐行高清标准
	videoSignalFormat1080sF,		///< 1080sF高清标准
	videoSignalFormat1_3M,			///< 1280*960信号
	videoSignalFormatNumber
}VideoSignalFormat;

/// 视频曝光模式
typedef enum VideoExposureMode
{
	videoExposureModeDefaultAuto = 0,	///< 默认自动曝光
	videoExposureModeLowNoise,			///< 低噪声（增益优先）
	videoExposureModeLowSmear,			///< 弱拖影（快门优先）
	videoExposureMode50HZFlickerless,	///< 50HZ防闪烁
	videoExposureMode60HZFlickerless,	///< 60HZ防闪烁
	videoExposureModeIris,				///< 光圈优先
	videoExposureModeManual,			///< 手动调节
	videoExposureModeHighLight,			///< 高亮优先
	videoExposureModeLowLight			///< 低亮优先
}VideoExposureMode;


/// smartIr灯类型
typedef enum VideoSmartIrType
{
	VideoSmartIrNear = 0x01,	///< 近光灯,也是单灯模式
	VideoSmartIrFar  = 0x02,	///< 远光灯
} VideoSmartIrType;

typedef enum VideoDayNightSwitchMode
{
	videoDayNightSwitchColor = 0,					///< 强制彩色
	videoDayNightSwitchPhotoresistor,				///< 光敏电阻切换
	videoDayNightSwitchSensorDetect,				///< sensor感光
	videoDayNightSwitchBlack,						///< 强制黑白
	videoDayNightSwitchIO,							///< 根据外部IO进行切换
	videoDayNightSwitchPhotoresistorThreshold,		///< 光敏电阻阈值切换
	videoDayNightSwitchMixture,						///< 混合模式
	videoDayNightSwitchModeNum
} VideoDayNightSwitchMode;

/// 视屏设备特性结构，128字节
typedef struct VideoInCaps
{
	/// 视频输入传感器最大水平感光分辨率，或者支持的外部视频输入最大分辨率
	int maxWidth;

	/// 视频输入传感器最大垂直感光分辨率，或者支持的外部视频输入最大分辨率
	int maxHeight;

	/// 视频输入支持的最高视频负载码流kbps，按16bpp计算，非binning模式下
	ulong ladenBitrate;

	/// 水平像素叠加功能掩码，从最低到最高每位依次对应是否支持2,3,4...像素叠加
	char horizontalBinning;

	/// 垂直像素叠加功能掩码，从最低到最高每位依次对应是否支持2,3,4...像素叠加
	char verticalBinning;

	/// 是否支持画面缩小，不包括binning模式
	char downScaling;

	/// 是否支持画面放大
	char upScaling;

	/// 曝光速度控制等级数，支持的曝光等级数，包括自动曝光。
	/// 0-不支持曝光控制，1-只支持自动曝光，2..n-曝光等级数。
	/// 速度在getExposureSpeeds接口中取到。
	int exposure;

	/// 是否支持背光补偿，，0表示不支持背光补偿，1支持，2-支持区域调节
	char backlight;

	/// 是否支持日夜颜色自动转换，0-不支持，1-支持
	char dayNightColor;

	/// 是否支持图像镜像，0-不支持，1-支持
	char mirror;

	/// 是否支持图像翻转，0-不支持，1-支持
	char flip;

	/// 是否支持白平衡，0-不支持，1-支持自动白平衡，2-也支持预置白平衡，3-也支持自定义白平衡,  4- 手动选择白平衡基准点
	char whiteBalance;

	/// 是否支持增益控制
	char gain;

	/// 是否支持自动增益
	char gainAuto;

	/// 支持最多的区域覆盖个数。
	char coverCount;

	/// 是否支持区域覆盖 0-不支持，1-支持实时的区域覆盖， 即设置区域时
	/// 速度较快，可以实时调用， 2-支持非实时的区域覆盖，即设置区域时速度较慢，
	/// 只能在用户确定区域后调用。  
	char coverType;

	/// 支持最多的标题叠加的个数。
	char titleCount;

	/// 是否支持光圈调节(手动)
	char iris;

	/// 是否支持光圈自动调节
	char irisAuto;

	/// 是否支持红外补偿，0-不支持，1-支持
	char infraRed;
	
	/// 是否支持颜色调节
	char setcolor;

	/// 前端支持输出分辨率数目，具体分辨率数值使用getFormatCaps接口函数获取。
	/// 如果值为0，表示前端格式采用编码的格式(比如分辨率、帧率)，不需要限制。
	char formatCount;

	/// 是否支持分辨率顺时针或逆时针旋转90°，0-不支持，1-支持
	char rotate90;

	/// 支持的视频输入信号格式掩码，\see VideoSignalFormat
	ulong signalFormatMask;

	/// 通道同步是指由于前端AD的限制，同一个芯片上的某个码流(主码流或辅码流)的多个
	/// 通道的分辨率必须一致。
	char syncChipChannels;
	
	/// 通道所在的芯片号
	char chipID;
	
	/// 是否支持多套选项，0-不支持，1-支持白天夜晚两套选项
	char multiOptions;
	
	/// 是否支持抓图单独曝光
	char snapshotExposure;

	/// 是否支持带时间上下限的自动曝光，0-不支持，1-支持
	char limitedAutoExposure;

	/// 是否支持用户自定义手动曝光时间，0-不支持，1-支持
	char customManualExposure;

	/// 是否支持外部同步信号输入，0-不支持，1-支持
	char externalSyncInput;

	/// 是否支持参考电压设置，0-不支持，1-支持
	char refrenceLevel;
	
	/// 是否支持闪光灯调节，0-不支持，1-支持
	char flashAdjust;

	/// 是否支持ircut控制，0-不支持，1-支持
	uchar ircut;
	
	/// 支持的最小曝光时间
	ushort minExposureTime;

	/// 支持的最大曝光时间
	ushort maxExposureTime;

	/// 支持的宽动态范围，0-不支持, 1-支持数字宽动态，2-支持真实宽动态。
	uchar wideDynamicRange;

	/// 是否支持双快门，0-不支持，1-支持双快门全帧率，2-支持双快门半帧率，3-支持双快门全帧率和双快门半帧率
	uchar doubleExposure;

	/// 抓拍支持的最小曝光时间
	ushort minExposureTime1;

	/// 抓拍支持的最大曝光时间
	ushort maxExposureTime1;

	/// 2A编译时间，对应的UTC(1970-1-1 00:00:00)秒数
	ulong utc;
	
	/// 2Asvn版本号
	ulong version;

	/// 最大测光区域个数
	uchar meteringRegionCount;

	///是否支持自动相位，0-不支持，1-支持
	char autoSyncPhase;

	/// 是否支持亮度补偿，如根据车牌亮度调整图像曝光，0-不支持，1-支持
	uchar brightnessCompensation;
	
	/// 是否支持强光抑制，0-不支持，1-支持
	uchar glareInhibition;
	
	/// 支持自动曝光模式掩码，详见VideoExposureMode
	uint exposureMode;

	/// 是否支持电动变焦，0-不支持，1-支持
	uchar electricFocus;

	/// 是否支持聚焦峰值计算，0-不支持，1-支持
	uchar afPeak;
	
	/// 视频最小曝光时间小数部分，范围：1~99，单位：0.01毫秒
	uchar minExposureTimeFrac;
	
	/// 视频最大曝光时间小数部分，范围：1~99，单位：0.01毫秒
	uchar maxExposureTimeFrac;
	
	/// 图片最小曝光时间小数部分，范围：1~99，单位：0.01毫秒
	uchar minExposureTime1Frac;
	
	/// 图片最大曝光时间小数部分，范围：1~99，单位：0.01毫秒
	uchar maxExposureTime1Frac;
	
	/// 支持的锐度可调节最大等级，支持 5，100
	uchar eeModeRange;

	/// 是否支持3D降噪，0-不支持，1-支持软件3D降噪，2-FPGA硬件3D降噪
	uchar tridimDenoise;
	
	/// 是否支持鱼眼算法，0-不支持，1-支持
	uchar fishEye;

	/// 抓拍是否支持帧匹配模式，0-不支持，1-支持
	uchar frameMatch;
	
	/// 是否支持3D降噪参数设置，0-不支持，1-支持,tridimDenoise为1时才有效
	uchar tridimDenoiseDetails;
	
	/// 3D降噪支持类型，0-支持视频和图片，1-只支持视频，2-只支持图片，tridimDenoise不为0时才有效
	uchar tridimDenoiseMode;

	/// 最大图片占空比
	float maxPicOccupy;
	
	/// 支持解交错,0-不支持，1-支持
	char deInterlace;

	/// 支持最大减光晕区域个数，0表示不支持
	uchar maxKillHaloRegion;
	
	/// 支持通过外部IO来控制ICR切换
	uchar dayNightColorIO;
	
	/// 是否支持同步对焦
	uchar syncFocus;

	/// 支持最小减光晕等级
	ushort minKillHaloLevel;
		
	/// 支持最大减光晕等级
	ushort maxKillHaloLevel;

	/// 是否支持smartIr功能，0-不支持，1-支持
	uchar smartIrMode;
	
	/// 是否支持畸变矫正功能，0-不支持，1-支持
	uchar ldc;
	
	/// 是否支持动态修改真实宽动态，0-不支持，1-支持 （不支持时切换需要重启设备）
	uchar dynRealWdr;

	/// 光圈能力掩码, 定义见VideoIrisMode
	uchar irisMask;

	/// 支持smartIr灯的类型掩码, 定义见VideoSmartIrType
	int smartIrMask;

	/// 支持日夜切换的类型掩码，定义见VideoDayNightSwitchMode
	int dayNightSwitchMask;

	/// 支持的聚焦模式，定义见VideoInFocusMode
	uchar focusMask;

	/// 是否支持数字防抖，0-不支持，1-支持
	uchar dis;

	uchar reserved1[2];

	int reserved[3];
} VideoInCaps;

typedef struct VideoInRedLightAdjustCaps//红灯涂红能力
{
	int maxWindows;//最多窗口数
	int maxS;//系数s最大值
	int minS;//系数s最小值
	int maxBegin;//系数begin最大值
	int minBegin;//系数begin最小值
	int maxA;//系数a最大值
	int minA;//系数a最小值
	int maxAutoColorLevel;//红黄灯自动识别系数最大值
	int minAutoColorLevel;//红黄灯自动识别系数最小值
	int reserved[7];//保留
}VideoInRedLightAdjustCaps;

/// 视屏设备特性结构扩展，1024字节
typedef struct VideoInCapsEx
{
	VideoInRedLightAdjustCaps redLightAdjustCpas;//红灯涂红能力
	int reserved[240];//保留字节
}VideoInCapsEx;

///图像模式
typedef enum ImageModeType
{
	imageModeTransparent = 0,			///<通透模式
	imageModeReal,						///<真实模式
	imageModeNum
}ImageModeType;

/// 白平衡预置模式
typedef enum WhiteBalancePreset
{
	whiteBalanceDisabled = 0,
	whiteBalanceAuto,
	whiteBalanceSunny,
	whiteBalanceCloudy,
	whiteBalanceHome,
	whiteBalanceOffice,
	whiteBalanceNight,
	whiteBalanceCustom,
	whiteBalanceHighColorTemperature,
	whiteBalanceLowColorTemperature,
	whiteBalanceAutoColorTemperature,
	whiteBalanceCustomColorTemperature,
	whiteBalanceIndoor,
	whiteBalanceOutdoor,
	whiteBalanceATW ,
	whiteBalanceManual,
	whiteBalanceAutoOutdoor,
	whiteBalanceSodiumAuto,
	whiteBalanceSodium,
	whiteBalanceManualDatum
} WhiteBalancePreset;

/// 视频输入抓拍选型结构，针对抓拍定义另一套参数，128字节
typedef struct VideoInSnapshotOptions
{
	int exposure;							///< 曝光等级0-自动曝光，1..n-1手动曝光等级数，n带时间上下限的自动曝光，n+1自定义时间手动曝光（n表示支持的曝光等级数）
	float exposureValue1;					///< 自动曝光时间下限或者手动曝光自定义时间，毫秒为单位，取值0.1ms~80ms
	float exposureValue2;					///< 自动曝光时间上限，毫秒为单位取值0.1ms~80ms，且必须不小于exposureValue1取值
	WhiteBalancePreset whiteBalance : 8;	///< 白平衡模式，0-不开启，1-自动白平衡，...参见WhiteBalancePreset
	int gain : 8;							///< 固定增益值，或者自动增益的上限，取值0-100。
	int gainAuto : 8;						///< 自动增益，0-不开启，1-开启，同时gain成员表示自动增益的上限。
	int reserved : 8;						///< 保留
	uchar colorTemperatureLevel;			///< 色温调节等级，whiteBalance为CustomColorTemperature时有效，取值0~255
	uchar gainRed;							///< 红色增益，whiteBalance为自定义模式时有效，取值0-100
	uchar gainGreen;						///< 绿色增益，whiteBalance为自定义模式时有效，取值0-100
	uchar gainBlue;							///< 蓝色增益，whiteBalance为自定义模式时有效，取值0-100
	int reserved1[27];						///< 保留
}VideoInSnapshotOptions;

/// 鱼眼镜头配置，128字节
typedef struct FishEyeOptions
{
	Point center;						///< 圆心坐标
	ushort direction;				///< 镜头方向, 是旋转角度乘以10，取值范围[0,3600]
	ushort radius;					///< 鱼眼配置，半径大小
	uchar placeHolder;						///< 鱼眼镜头安装位置
	ulong reserved[28];
} FishEyeOptions;

/// 视频输入选项结构，128字节
typedef struct VideoInOptions
{
	char backlight;						///< 是否启用背光补偿，0-不启用，1-启用背光补偿，2-启用指定区域背光补偿
	char dayNightColor;					///< 日夜转换模式设置，0-强制彩色，1-根据光敏电阻切换，2-感光阈值切换，3-强制黑白，4-根据外部IO进行切换，5-根据光敏阈值进行切换，6-混合切换（彩转黑用感光阈值切换模式，黑转彩光敏电阻切换）
	char mirror;						///< 是否开启镜像功能，0-不开启，1-开启
	char flip;							///< 是否开启翻转功能，0-不开启，1-开启
	int exposure;						///< 曝光等级0-自动曝光，1..n-1手动曝光等级数，n带时间上下限的自动曝光，n+1自定义时间手动曝光（n表示支持的曝光等级数）
	WhiteBalancePreset whiteBalance : 8;///< 白平衡模式，0-不开启，1-自动白平衡，...参见WhiteBalancePreset
	int gain : 8;						///< 固定增益值
	int gainAuto : 8;					///< 自动增益，0-不开启，1-开启，同时gain成员表示自动增益的上限。
	int infraRed : 8;					///< 自动红外补偿，0-不开启，1-开启
	VideoSignalFormat signalFormat : 8;	///< 信号格式
	int rotate90 : 8;					///< 分辨率旋转标志。0-不旋转，1-顺时针90°，2-逆时针90°。分辨率旋转后，VideoEnc和VideoIn的分辨率和视野窗口也要做相应旋转。
	int externalSyncPhase : 16;			///< 外部同步信号相位，取值0~360°
	float exposureValue1;				///< 自动曝光时间下限或者手动曝光自定义时间，毫秒为单位，取值0.1ms~80ms
	float exposureValue2;				///< 自动曝光时间上限，毫秒为单位取值0.1ms~80ms，且必须不小于exposureValue1取值
	char  refrenceLevel;				///< 参考电压，参考电平，即期望的每帧图像的平均亮度等级，取值0-100
	uchar gainRed;						///< 红色增益，whiteBalance为自定义模式时有效，取值0-100
	uchar gainGreen;					///< 绿色增益，whiteBalance为自定义模式时有效，取值0-100
	uchar gainBlue;						///< 蓝色增益，whiteBalance为自定义模式时有效，取值0-100
	uchar flashMode;					///< 闪光灯工作模式，0-禁止闪光，1-始终闪光，2-自动闪光
	uchar flashPole;					///< 闪光灯触发模式,0-低电平 1-高电平 2-上升沿 3-下降沿
	ushort flashValue;					///< 闪光灯时间，us为单位；
	char externalSync;					///< 是否开启外同步，0-不开启，1-开启
	uchar brightnessThreshold;			///< 亮度阈值预设值，环境亮度低于此值开启闪光灯，取值范围[0, 100]，仅用于控制闪光灯，不做日夜切换用
	char optionsIndex;					///< 选项序号，0-白天选项，1-夜晚选项
	uchar doubleExposure;				///< 是否开启双快门，0-不开启，1-双快门全帧率，2-双快门半帧率
	float exposureValue3;				///< 抓拍张单独最大曝光时间，毫秒为单位取值0.1ms~80ms，如果不支持单独曝光，值无意义
	ushort externalSyncPhase1;			///< 外部同步信号相位值的小数部分，范围1~999，实际外同步相位值为:externalSyncPhase+externalSyncPhase1/1000
	uchar wideDynamicRange;				///< 宽动态范围，0-关闭，1-弱，2-中，3-强
										///< 0-255宽动态范围，0等同于关闭
	uchar wideDynamicRangeMode;			///< 宽动态模式，0-初始化，1-强制打开，2-自动调节
	VideoInSnapshotOptions *snapshot;	///< 抓拍特殊选项
	uchar colorTemperatureLevel;		///< 色温调节等级，whiteBalance为自定义时有效，取值0~255
	uchar dutyCycle;					///< 频闪灯占空比，范围0~100
	uchar frequencyMultiple;			///< 频闪灯倍频，范围0~10
	char autoSyncPhase;					///< 自动相位调节，0-不开启，1-开启
	float externalSyncPhase2;			///< 启用自动相位时，externalSyncPhase2和externalSyncPhase 作为自动相位的上下限
	Rect backLightRegion;				///< 背光补偿区域
	uint glareInhibition : 8;			///< 强光抑制范围，0-关闭，1-弱，2-中，3-强
	uint gainMin : 8;					///< 增益下限，范围0-100,且小于gain（上限）的值
	uint exposureMode : 8;				///< 曝光模式节，曝光等级为自动曝光时有效，取值：0-自动，1-增益优先，2-快门优先，3-50hz防闪烁，4-60HZ防闪烁，5-光圈优先，6-手动调节，7-高亮优先，8-低亮优先 同枚举VideoExposureMode
	uint gainMax : 8;					///< 增益上限，范围0~100
	uint antiFlicker : 8;				///< 防闪烁模式，0-Outdoor, 1-50Hz防闪烁, 2-60Hz防闪烁
	uint pad1 : 24;						///< 占位
	FishEyeOptions *fishEye;			///< 鱼眼算法配置
	uchar colorTemperatureLevel2;		///< 色温调节等级，whiteBalance为自定义时有效，取值0~255
	Rect whiteBalanceManualRect;
/*====================================================================*/	
	uchar colormode;					///< 色彩模式 0=标准 ,1=自然,2= 艳丽
	uchar compansation; 				///< 期望亮度值
	uchar shutter;						///< 快门对应的值
	uchar daynighdelay; 				///< 亮度自动日夜切换时的缓冲时间
/*======新增加的变量==	reserved[10]=> reserved[9]==保持结构体长度不变====*/
	uchar delog;						///< 透雾能力范围，0-关闭，1-弱，2-中，3-强
	ImageModeType imageMode : 8;		///< 图像模式，0=通透模式，1=真实模式
	short flashDelayTime;				///< 闪光灯延时时间，单位us，负数表示提前闪光

	union DayNightThr
	{
		struct Photoresistor
		{
			uchar night2DayThreshold;	///< 光敏电阻黑转彩阈值，范围0~100
			uchar day2NightThreshold;	///< 光敏电阻彩转黑阈值，范围0~100
		}photoresistor;

		struct Senosor
		{
			uchar night2DayThreshold;	///< sensor感光黑转彩阈值，范围0~100
			uchar day2NightThreshold;	///< sensor感光彩转黑阈值，范围0~100
		}senosor;

		struct MixMode
		{
			uchar day2NightThreshold;	///< 混合模式彩转黑阈值，范围0~100
		}mixMode;
	}dayNightThr;
	char lenPowerUpCorrect;				///< 重启后镜头自动变焦矫正,0-不开启，1-开启
	ushort colorTemp;
	uchar reservedBytes[3];
	int reserved[2];					///< 保留字节
} VideoInOptions;

/// 视频输入预处理选项，128字节
typedef struct VideoInPreviewOptions
{
	uchar refrenceLevel;				///< 参考电压，参考电平，即期望的每帧图像的平均亮度等级，取值0-100
	uchar blackLevelMode;				///< 黑电平处理模式，0-自动检测，1-手动设置
	short blackLevel;					///< 黑电平参数值，取值-1024~1023
	uchar shutterStepLevel;				///< 快门步长等级，取值0~10
	uchar apertureStepLevel;			///< 光圈步长等级，取值0~10
	uchar gainStepLevel;				///< 增益步长等级，取值0~10
	uchar aeSensitivity;				///< AE调节灵敏度	
	uchar NFMode[2];					///< 降噪模式，取值0~5，数组元素0，1分别是视频和抓拍模式
										///< 0-表示自动，1-255表示降噪等级
	uchar GammaMode[2];					///< Gamma模式，数组元素0，1分别是取值0~5，视频和抓拍模式
	uchar EEMode[2];					///< 锐度模式，取值0~5，数组元素0，1分别是视频和抓拍模式
										///< 0-表示自动，1-255表示锐度等级
	uchar CFAMode[2];					///< 插值模式，取值0~4，数组元素0，1分别是视频和抓拍模式
	uchar CCMMode[2];					///< 颜色转换矩阵，取值0~4，数组元素0，1分别是视频和抓拍模式
	uchar CGSMode[2];					///< 色度抑制，取值0~2，数组元素0，1分别是视频和抓拍模式		
	uchar optionsIndex;					///< 预处理参数对应的选项模式，0:白天，1:傍晚，2:晚上，3:清晨
	uchar brightnessCompensation;		///< 是否打开亮度补偿，0-不开启，1-开启
	uchar brightnessCompensation1;		///< 顺光亮度补偿等级，范围0~100
	uchar brightnessCompensation2;		///< 逆光亮度补偿等级，范围0~100
	uchar badPixelCorrection;			///< 坏点校正等级，范围0~4
	uchar tridimDenoise;				///< 是否开启3D降噪，0-关闭，1-开启，2-只开启视频，3-只开启图片, 4-自动
	uchar gammaAuto[2];					///< 是否开启自动Gamma模式，0-关闭，1-开启，视频和抓拍模式
	uchar tridimEstimation;				///< 三维降噪噪声估计值，取值范围0-100，整型
	uchar tridimIntensity;				///< 三维降噪时域降噪强度，取值范围0-32，整型
	uchar blBrightnessCompensation;		///< 强逆场景是否打开亮度补偿，0-不开启，1-开启
	uchar olBrightnessCompensation;		///< 强顺场景是否打开亮度补偿，0-不开启，1-开启
	uchar expBlThreshold1;				///< 强逆场景下目标亮度调整阈值1
	uchar expBlThreshold2;				///< 强逆场景下目标亮度调整阈值2
	uchar expOlThreshold1;				///< 强顺场景下目标亮度调整阈值1
	uchar expOlThreshold2;				///< 强顺场景下目标亮度调整阈值2
	uchar threeDNFMode[2];				///< 3D降噪模式，取值0~5，数组元素0，1分别是视频和抓拍模式
										///< 1-255表示降噪等级
	uchar deInterlace;					///< 解交错：0：关闭，1：开启
	int reserved[22];					///< 保留字节
}VideoInPreviewOptions;


/// 聚焦算法选项
typedef struct VideoInFocusOptions
{
	Rect rect;					///< 聚焦算法参照区域
	int reserved[28];			///< 保留
} VideoInFocusOptions;


/// 聚焦状态，128字节
typedef struct VideoInFocusStatus
{
	int 	afPeak;				///< Autofocus Peak Sum
	float	focus;				///< 聚焦位置，归一化到0~1
	float	zoom;				///< 放大倍率，归一化到0~1
	char	status;				///< 聚焦状态，0-正常 1-正在聚焦
	char	reservedBytes[3];	///< 保留
	int		reserved[28];		///< 保留
} VideoInFocusStatus;


/// 视频输入状态，128字节
typedef struct VideoInStatus
{
	uchar brightness[2];				///< 亮度，视频和图片
	uchar gain[2];						///< 增益值，视频和图片
	float exposureValue[2];				///< 曝光时间，视频和图片，ms为单位
	uchar syncPhaseStatus;				///< 相位状态，0:白天，1:傍晚，2:晚上
	char reserved1[1];					///< 保留
	uchar gainRed[2];					///< 红色增益值，视频和图片
	uchar gainGreen[2];					///< 绿色增益值，视频和图片
	uchar gainBlue[2];					///< 蓝色增益值，视频和图片
	int reserved[27];					///< 保留
}VideoInStatus;

/// 视频制式类型
typedef enum VideoStandard
{
	videoStandardPAL = 0,	///< PAL制式。
	videoStandardNTSC,		///< NTSC制式。
	videoStandardSECAM,		///< SECAM制式。
	videoStandardNr
} VideoStandard;


/// 视频颜色格式
typedef struct VideoColor
{
	char	brightness;		///< 亮度，取值0-100。
	char	contrast;		///< 对比度，取值0-100。
	char	saturation;		///< 饱和度，取值0-100。
	char	hue;			///< 色调，取值0-100。
}VideoColor;


/// 视频区域覆盖参数，128字节
typedef struct VideoCover
{
	/// 序号。
	char index;

	/// 使能标志：1-区域覆盖使能；0-清除区域覆盖，结构的其他成员忽略。
	char enable;

	/// 区域覆盖区域
	Rect	rect;

	/// 区域覆盖的颜色。
	Color color;

	/// 保留字节
	int reserved[26];
} VideoCover;


/// 视频标题叠加参数结构，128字节
typedef struct VideoTitle
{
	/// 标题序号，最多支持的标题数从VideoEncGetCaps可以取得。序号0对应的是
	/// 时间标题。时间标题点阵由底层内部产生，width,height参数被忽略, 而raster
	/// 表示时间字符串。
	char index;

	/// 是否显示。0-不显示，其他参数忽略，1-显示。
	char enable;

	/// 颜色深度，1表示单色位图，16表示RGB565位图，0表示data为ASCII带0结束符的字符串
	char bpp;
	
	/// 帧标记，即在snapshot函数中获取的值，如果mark有效，则标题只对标记相同的帧
	/// 进行叠加。因此标题数据和帧数据应该有一定的缓冲，新的标题或帧产生时从缓冲
	/// 里找到对应的项来叠加。如果为0表示对所有帧一直叠加，无须比较帧标记。
	uchar mark;

	/// 标题左上角x坐标
	short	x;		

	/// 标题左上角y坐标
	short	y;

	/// 标题宽度。					
	short	width;		

	/// 标题高度。
	short	height;		

	/// 前景颜色。	
	Color	fgColor;

	/// 背景颜色。
	Color	bgColor;

	/// 如果为单色单色点阵数据，0表示该点取bgColor颜色，1表示该点取fgColor颜色。
	/// 每个字节包含8个象素的数据，最左边的象素在最高位，紧接的下一个字节对应
	/// 右边8个象素，直到一行结束，接下来是下一行象素的点阵数据。
	/// 如果是16色位图，每两个字节表示一个像素的实际颜色值。
	uchar	*data;
	
	/// 当前UTC(1970-1-1 00:00:00)秒数，如果表示为时间标题，则标题时间和utc必须对应。
	ulong utc;

	/// 编码视频源地址
	void *source;

	/// 帧序号，当帧序号匹配时叠加OSD，是否进行帧序号匹配，由其它接口指定。
	ulong sequence;

	/// UTC时间对应的毫秒数
	ushort utcms;

	/// 保留字节
	char reserved1[2];
	
	/// 保留字节
	int reserved[22];
}VideoTitle;


/// 视频物件顶点集结构，描述一个折线或者多边形，视使用的语境而定
typedef struct VideoWidgetVertexes
{
	Point*		vertexes;	///< 构成折线或者多边形区域的点的集合
	uint		count;		///< 顶点数目，折线必须不小于2，多边形不小于3
} VideoWidgetVertexes;


/// 视频辅助线叠加参数结构，128字节
typedef struct VideoWidgetLine
{
	/// 序号
	char index;

	/// 是否显示。0-不显示，其他参数忽略，1-显示。
	char enable;

	/// 线型宽度。归一化到 [0,8192]
	short width;		

	/// 前景颜色。	
	Color fgColor;

	/// 背景颜色。
	Color bgColor;

	/// 折线顶点集。点的坐标归一化到 [0,8192)
	VideoWidgetVertexes	polyline;

	/// 保留字节
	int reserved[27];
}VideoWidgetLine;


/// 视频输入数据格式结构，128字节
typedef struct VideoInFormat
{
	/// width和height指视频前端的输出分辨率，此分辨率就是视频编码的输入分辨率
	/// 水平分辨率，8的倍数,大于64 
	int		width;

	/// 垂直分辨率，8的倍数,大于64
	int		height;

	/// 设置视野区域，是指在感光输入区域中选取一个矩形窗口，作为输出的原始数据
	/// 区域，经过缩小处理后，作为输出数据。视野区域一定要在感光分辨率之内，见
	/// VideoInCaps结构中的最大感光区域。同时，视野区域的长和宽要大于输出的分辨
	/// 率。如果可视区域长或者宽是输出分辨率长或者宽的整数倍以上，应自动启动
	/// Binning像素压缩功能单元，以保证图像质量和节省带宽。4个坐标必须是4的倍数
	Rect	window;	

	/// 帧率值，NTSC/PAL不区分
	float	fps;

	/// 保留字节
	int reserved[25];
} VideoInFormat;


/// 视频输入抓拍结构体，32字节
typedef struct VideoInSnapshot
{
	/// 应用层调用snapshot接口时，底层产生的下一帧的标志，表示是由应用程序触发的
	/// 抓图，区别于非触发的抓图，取值范围1-255。底层标志需要循环使用，来区分不
	/// 同的帧。这个标记将随着原始视频帧数据一直传给DSP编码，最终传给应用层，应用
	/// 程序通过标记编号和原来的触发信息对应起来。底层不能返回为0的标志，因为应用
	/// 程序获取的标志为0的帧表示是标志无效的帧，也就是非触发抓图的帧。如果多次
	/// 触发是在同一个VD周期内，取到的mark编号应该相同，表示多次触发的抓拍图片是
	/// 同一张。
	uchar	mark;
	
	/// 闪光灯使能，表示曝光时闪光灯需要闪光。同时该帧是否曝光还取决与VideoInOptions
	/// 里面的闪光模式参数，两者逻辑上是与的关系。
	uchar	flash;
	
	/// 连续抓拍的张数
 	uchar times;
 
 	/// 抓拍多张时的帧间隔，0表示不隔帧，连续抓拍
 	uchar period;
 	
 	/// 抓拍的车道或通道编号，一个视频输入可以对应多个车道或通道
 	uchar lane;
 
 	/// 保留
	int reserved[6];
}VideoInSnapshot;


/// 视频输入采集模式
typedef enum VideoInMode
{
	/// 禁止视频输入采集，如果在视频切换模式的同时，也要设置采集输入的数据格式，
	/// 则应设置输入格式和其他参数之后，再切换到其他采集模式，避免模式和格式不同步。
	videoInModeDisabled,
	
	/// 抓拍模式，平时视频输入处于等待状态，当调用snapshot接口函数进行触发时，
	/// 进行单次或连续多次抓拍，抓拍的次数，是否开启闪光灯，抓拍的标记等可以设置。
	videoInModeSnapshot,
	
	/// 连续采集模式，视频输入按照设置的帧率连续工作，采集原始数据，同时也可以调用
	/// snapshot接口函数进行触发，设置帧标志，开始闪光灯等，来采集特定时刻的帧。
	videoInModeContinuous
}VideoInMode;

typedef struct VideoInColorAdjustArea
{
	char			enable;				///< 是否调节，0-不调节，1-调节
	char			type;				///< 0-交通灯
	union
	{
		struct TrafficLight
		{
			//灯组个数
			uint groupsNumber;

			struct VideoAnalyseTrafficLightGroup* lightGroups;
		}trafficLight;
		
		int placeholder[24]; 			///< 占位符，保证这个联合体体为96字节
	}detail;
	int				reserved[7];		///< 保留
}VideoInColorAdjustArea;

/// 视频输入测光模式，32字节
typedef struct VideoInMeteringMode
{
	uchar	mode;			///< 测光模式,0:平均测光,1:局部测光,2:点测光
	uchar	count;			///< 测光区域个数
	uchar	reserced1[2];	///< 保留字节
	Rect	*regions;		///< 测光区域指针，采用绝对坐标，分辨率变化需要重新设置参数
	int		reserved[6];	///< 保留字节
}VideoInMeteringMode;


/// 
typedef enum VideoScanMode
{
	videoScanModeInterlaced = 0,	///< 隔行扫描
	videoScanModeProgressive,		///< 逐行扫描
	videoScanModeNumber
}VideoScanMode;

typedef enum VideoCapturePolarity
{
	VideoCapturePolarityPositive = 0,	///< 上升沿采集
	VideoCapturePolarityNegative,		///< 下降沿采集
	VideoCapturePolarityNumber
}VideoCapturePolarity;

typedef enum VideoFieldPolarity
{
	VideoFieldPolarityEven = 0,	///< 偶场优先
	VideoFieldPolarityOdd,		///< 奇场优先
	VideoFieldPolarityNumber
}VideoFieldPolarity;

/// 视频采集分辨率参数,128字节
typedef struct VideoCapResOptions
{
	int  width;            ///< 输出分辨率的宽度
	int  height;           ///< 输出分辨率的高度
	float   fps;           ///< 输出分辨率能支持的最大帧率
	Rect  margin;     		 ///< 此分辨率对应sensor输出图像左右偏移
	uchar	scanMode;        ///< 视频扫描模式, 见：VideoScanMode
	uchar	signalFormat;    ///< 视频输入格式：见：VideoSignalFormat
	uchar	hdPol;           ///< HD采集极性, 见：VideoCapturePolarity
	uchar	vdPol;           ///< VD采集极性, 见：VideoCapturePolarity
	uchar	fdPol;           ///< 场极性, 见：VideoFieldPolarity
	int		reserved[23];	 ///< 保留位
}VideoCapResOptions;

/// 视频输入传感器参数，128字节
typedef struct VideoInSensorOptions
{
	Rect	availableRegion;		///< 有效像素区域
	VideoCapResOptions	*options;	///< 支持的采集方式支持表，数量由count决定
	int		count;
	char	realWideDynamic;	///< 0: 关闭真实宽动态 1: 开启真实宽动态 2: 自动调节
	char	reserved1[3];		///< 保留位
	int		reserved[25];		///< 保留位
} VideoInSensorOptions;

/// 降噪参数结构体，总共128字节,
typedef  struct
{
	uchar tridimDenoise;            ///< 是否开启3D降噪，0-关闭，1-自动模式， 2-手动模式
	uchar pad1[3];					///< 保留
	union
	{
		struct
		{
			uchar mod;		///< 0 表示强；1表示中；2表示弱
			uchar level;	///< 等级
		}AutoType;
		struct 
		{
			uchar tnfLevel;	///< 时域等级
			uchar snfLevel;	///< 空域等级
		}manulType;
		char placeholder[8]; ///< placeholder for 8 bytes
	}tridimDenoiseDetail;
	uchar level2D;                          ///< 2D降噪等级，0表示关闭(0~255)
	uchar resv[115];
} VideoInDenoise;


/// 降噪参数结构体，总共64字节
typedef  struct
{
    uchar tnf3TS;          ///<  时域参数 : tnf3TS
    uchar tnfThreshold;    ///<           : Threshold
    uchar tnfBlending;     ///<           : Blending
    uchar snfYfilter[3];   ///<  空域参数 :Y 滤波
    uchar snfUfilter[3];   ///<           :U 滤波
    uchar snfVfilter[3];   ///<           :V 滤波  
    uchar res[52];               ///<  保留
} VideoInDenoiseParams;

/// 降噪参数结构体描述，共32个字节：
typedef struct VideoInDenoiseParamsDesc
{
	uchar type;						///< 0 表示自动模式，1表示手动模式
	uchar levels;					///< 总共有多少等级n
	uchar modusPerLever;			///< 每个等级有几种模式
	uchar res[29];
} VideoInDenoiseParamsDesc;

/// 减光晕参数结构体，总共64字节
typedef struct VideoInKillHalo
{
	Rect		region;					///< 减光晕区域，采用相对坐标
	ushort		level;					///< 减光晕等级
	uchar		reserved1[2];			///< 保留
	int			reserved[11];			///< 保留
} VideoInKillHalo;

/// 外同步相位控制结构体，总共64字节
typedef struct VideoInSyncPhase
{
	float externalSyncPhase;	///< 外部同步信号相位
	char  externalSync;			///< 是否开启外同步，0-不开启，1-开启
	uchar reserved1[3];			///< 保留
	int	  reserved[14];			///< 保留
}VideoInSyncPhase;

///采集输入状态结构体，总共64字节
typedef struct VideoInPutStatus
{
	uchar  rebootState;   ///< 重启状态，0:系统无需重启，1:系统需重启
	uchar  rebootReason;  ///< 重启原因,掩码形式。bit0:采集，bit1:编码，bit2:DSP。
						  ///< 如:101:表示采集和DSP出异常，编码正常
	uchar  reserved1[2];  ///< 保留
	int	   reserved[15];  ///< 保留
}VideoInPutStatus;


/// 红灯涂红
typedef struct VideoInRedLightAdjust
{
	int		enable;		///< 红灯涂红使能
	Rect	rect;		///< 红灯区域
	int		s;			///< 系数s
	int		begin;		///< 系数begin
	int		a;			///< 系数a
	int		autoColor;	///< 红黄灯自动识别，1、自动识别，0、不自动识别
	int		autoColorLevel;	///< 红黄灯自动识别系数?
	int		reserved[24];	///< 保留
}VideoInRedLightAdjust;

///白平衡参数结构体，总共128字节
typedef struct
{
	WhiteBalancePreset mode : 8;	///< 白平衡模式，0-不开启，1-自动白平衡，...参见WhiteBalancePreset
	uchar redGain;					///< 红色增益(0~100)
	uchar blueGain;					///< 蓝色增益(0~100)
	uchar resv[125];				///< 保留
} VideoInWhiteBalance;

///曝光参数结构体，总共128字节
typedef struct VideoInExposure
{
	VideoExposureMode mode : 8;		///< 曝光模式，参见enum VideoExposureMode
	uchar gain;						///< 手动增益(0~255)
	uchar iris;						///< 光圈(0~255)
	uchar exposureCompensation;		///< 曝光补偿(0~255)
	uint shutterSpeed;				///< 快门，取分母，1/n 传 n
	uchar autoGainMax;				///< 自动增益上限(0~255)
	uchar slowShutter;				///< 慢快门 0-关闭，1-打开
	uint slowShutterLimit;			///< 自动慢快门下限，取分母，1/n 传 n
	uchar WDRMode;					///< 宽动态模式 0-关闭，1-打开，2-自动
	uchar glareInhibition;			///< 强光抑制 0-关闭，1-低，2-高
	uchar backlight;				///< 背光补偿 0-关闭，1-打开
	uchar slowAutoExposure;			///< 慢曝光(0~255)
	uchar recoveryTime;				///< 自动曝光恢复 单位为秒，0表示关闭
	uchar resv[107];				///< 保留
} VideoInExposure;


typedef enum VideoDayNightMode
{
	videoDayNightBlack = 0,		///< 黑白
	videoDayNightColor,			///< 彩色
	videoDayNightBrightness,	///< 自动
	videoDayNightPhotoresistor	///< 光敏电阻
} VideoDayNightMode;

///参数结构体，总共128字节
typedef struct
{
	uchar type;						///< 彩转黑类型 0-机械，1-电子
	VideoDayNightMode mode:8;		///< 彩转黑模式, 参见enum CAM_ICR_MODE
	uchar sensitivity;				///< 彩转黑灵敏度(0~255)
	uchar resv[125];				///< 保留
} VideoInDayNight;

/// 聚焦模式
typedef enum VideoInFocusMode 
{
	videoInFocusDisable,			///< 关闭
	videoInFocusAssist,				///< 辅助
	videoInFocusAuto,				///< 自动
	videoInFocusSemiAutomatic,		///< 半自动
	videoInFocusManual,				///< 手动
	videoInFocusModeNum
} VideoInFocusMode;

///数结构体，总共128字节
typedef struct
{
	VideoInFocusMode mode:8;		///< 聚焦模式，参见enum CAM_FOCUS_MODE
	uchar sensitivity;				///< 聚焦灵敏度 0-高，1-默认，2-低
	uchar IRCorrection;				///< 红外光聚焦修正 0-不修正，1-修正，2-自动修正
	uint focusLimit;				///< 聚焦极限单位为毫米
	uchar resv[120];				///< 保留
} VideoInFocus;

///数结构体，总共128字节
typedef struct
{
	uchar speed;					///< 变倍速度(0~255)
	uchar digitalZoom;				///< 数字变倍 0-关闭，1-开启
	uchar resv[126];				///< 保留
} VideoInZoom;

///数结构体，总共128字节
typedef struct
{
	uchar sharpness;				///< 锐度(0~255)，手动的时候有效
	uchar level;					///< 锐度抑制等级(0~255)
	uchar resv[126];				///< 保留
} VideoInSharpness;

///色参数结构体，总共128字节
typedef struct
{
	uchar hue;						///< 色调(0~100)
	uchar brightness;				///< 亮度(0~100)
	uchar saturation;				///< 饱和度(0~100)
	uchar chromaSuppress;			///< 色彩抑制(0~100)
	uchar gamma;					///< 伽马(0~100)
	uchar resv[123];				///< 保留
} VideoInColor;

///图像旋转参数结构体，总共128字节
typedef struct
{
	uchar flip;						///< 图像翻转0-关闭，1-开启
	uchar freeze;					///< 图像冻结0-关闭，1开启
	uchar resv[126];				///< 保留
} VideoInRotate;

/// 获取前端支持分辨的特征属性，总共32字节
typedef struct VideoInFormatOptions
{
	VideoStandard	standard;				///< 视频制式
	uchar			wideDynamic;			///< 真实宽动态状态，0-不开启，1-开启真实宽动态，2-自动调节					
	uchar			reserved1[3];			///< 保留值
	int				reserved[30];			///< 保留值
} VideoInFormatOptions;

/// smartIr配置参数，总共128字节
typedef struct VideoInSmartIrParams
{
	uchar mode;				        ///< 0: 手动模式 1: 自动模式 2:关闭红外
	uchar level;					///< 手动模式时，smartIr的强度，范围:0~100
	uchar resv1[2];					///< 保留
	VideoSmartIrType type;			///< smartIr灯类型
	uchar resv[120];				///< 保留
} VideoInSmartIrParams;

typedef enum VideoIrisMode
{
	videoIrisLockMax = 0,			    ///< 锁定最大
	videoIrisManual,				    ///< 手动
	videoIrisAuto,				        ///< 自动
	videoIrisModeNum
} VideoIrisMode;

/// 自动光圈配置参数，总共32字节
typedef struct VideoInAutoIrisParams
{
	uchar level;				///< 自动光圈灵敏度，范围:0~100
	uchar resv[31];				///< 保留
} VideoInAutoIrisParams;

/// 光圈配置参数，总共64字节
typedef struct VideoInIrisParams
{
	VideoIrisMode mode:8;       ///< 光圈模式

	union
	{
		VideoInAutoIrisParams autoPrms;				///< 自动模式设置参数
		uchar reserved[32];
	}params;

	uchar resv[31];				///< 保留
} VideoInIrisParams;

/// 畸变矫正参数，总工64字节
typedef struct VideoInLDCParams
{
	uchar	mode;			///< 0:关闭,1:手动开启
	uchar	ratio;			///< 矫正强度,0~100
	uchar	reserved1[2];	///< 保留位
	float	xOffset;		///< 画面中心点x轴偏移,范围-1~1
	float	yOffset;		///< 画面中心点y轴偏移,范围-1~1
	int		reserved[13];	///< 保留位
}VideoInLDCParams;

/// 感觉类型
typedef enum VideoLdrType
{
	videoLdrIo = 0,	    ///< io模式
	videoLdrAd = 1,	    ///< ad采样模式
	videoLdrTypeNumber
}VideoLdrType;

/// 感觉参数，总工64字节
typedef struct VideoInLdrParams
{
    int ldrType;        ///< 定义见VideoLdrType
    int reserved[7];

    union
    {
        /* 感觉值
           adc模式: 0~10000区间光线越亮值越大.
           io模式: 只返回0或1. */
        int value;
        int reserved[55];
    } ldrValue;
}VideoInLdrParams;

typedef enum VideoInFecAppType
{
	VIDEOIN_FEC_APP_CEIL = 0,		///< 天花板模式，不适用于180度展开
	VIDEOIN_FEC_APP_TABL = 1,		///< 桌面模式
	VIDEOIN_FEC_APP_WALL = 2,		///< 壁挂模式，不适用于360度展开
}VideoInFecAppType;

/// 鱼眼矫正PTZ模式信息
typedef struct VideoInPtzInfo
{
	unsigned int xCoord;			///< 水平坐标，取值范围0~8192
	unsigned int yCoord;			///< 竖直坐标，取值范围0~8192
	float zoom;						///< 配置放大倍数，取值范围0~1
    float focal;					///< 配置焦距，取值范围0~1
}VideoInPtzInfo;

/// 鱼眼矫正ORIG模式信息
typedef struct VideoInOrigInfo
{
	float zoom;						///< 配置放大倍数，取值范围0~1
}VideoInOrigInfo;

/// 鱼眼矫正180度模式信息
typedef struct VideoInp180Info
{
	unsigned int yCoord;			///< 竖直坐标，取值范围0~8192
	float zoom;						///< 配置放大倍数，取值范围0~1
    float focal;					///< 配置焦距，取值范围0~1
	float curvature;				///< 画面曲率，默认0.65
	float slope;					///< 画面斜度，默认0.8
}VideoInp180Info;

/// 鱼眼矫正360度模式信息
typedef struct VideoInP360Info
{
	unsigned int xCoord;			///< 水平坐标，取值范围0~8192
	unsigned int yCoord;			///< 竖直坐标，取值范围0~8192
	float zoom;						///< 配置放大倍数，取值范围0~1
    float focal;					///< 配置焦距，取值范围0~1
}VideoInP360Info;	

/// 鱼眼矫正支持模式
typedef enum VideoInFecMode
{
	VIDEOIN_FECMODE_1R = 0,
	VIDEOIN_FECMODE_4R,
	VIDEOIN_FECMODE_1P2R,
	VIDEOIN_FECMODE_1O3R,
	VIDEOIN_FECMODE_P180_ALL,
	VIDEOIN_FECMODE_P180_ONEDIRECTION,
	VIDEOIN_FECMODE_P180_TWODIRECTION,
	VIDEOIN_FECMODE_P360_FULL,
	VIDEOIN_FECMODE_P360_SEPARATE,
	VIDEOIN_FECMODE_P360_HALF,
	VIDEOIN_FECMODE_ORIGINAL,
	VIDEOIN_FECMODE_NUM,
}VideoInFecMode;

/// 原始图像模式配置结构体
typedef struct VideoInFecConfigOrig
{
	VideoInOrigInfo origInfo;		///< ORIG区域信息
}VideoInFecConfigOrig;

/// 虚拟云台1个感兴趣区域展开配置结构体
typedef struct VideoInFecConfigPTZ1R
{
	int ptzNum;						///< PTZ模式下，PTZ区域的个数，1R=1，4R=4，1P2R=2
	VideoInPtzInfo ptzInfo;			///< PTZ各个区域的信息
}VideoInFecConfigPTZ1R;

/// 虚拟云台4个感兴趣区域展开配置结构体
typedef struct VideoInFecConfigPTZ4R
{
	int ptzNum;						///< PTZ模式下，PTZ区域的个数，1R=1，4R=4，1P2R=2
	VideoInPtzInfo ptzInfo[4];		///< PTZ各个区域的信息
}VideoInFecConfigPTZ4R;

/// 虚拟云台2个感兴趣区域及1个180度展开配置结构体
typedef struct VideoInFecConfig1P2R
{
	int ptzNum;						///< PTZ模式下，PTZ区域的个数，1R=1，4R=4，1P2R=2
	VideoInp180Info p180Info;		///< 180度模式信息
	VideoInPtzInfo ptzInfo[2];		///< PTZ各个区域的信息
}VideoInFecConfig1P2R;

/// 虚拟云台3个感兴趣区域展开及1个原始图像配置结构体
typedef struct VideoInFecConfig1O3R
{
	int ptzNum;						///< PTZ模式下，PTZ区域的个数，1R=1，4R=4，1P2R=2
	VideoInOrigInfo OrigInfo;		///< ORIG区域信息
	VideoInPtzInfo ptzInfo[3];		///< PTZ各个区域的信息
}VideoInFecConfig1O3R;

/// 180度展开模式配置结构体
typedef struct VideoInFecConfigP180
{
	VideoInp180Info p180Info;		///< 180度模式信息
}VideoInFecConfigP180;

/// 360度展开模式配置结构体
typedef struct VideoInFecConfigP360
{
	VideoInP360Info p360Info;		///< 360度模式信息
}VideoInFecConfigP360;

/// 鱼眼矫正信息结构体，64字节
typedef struct VideoInFecInfo
{
	int fecEnable;					///< 鱼眼矫正使能
	VideoInFecMode fecMode;			///< 鱼眼矫正模式
	VideoInFecAppType appType;		///< 鱼眼矫正场景类型

	union
	{
		VideoInFecConfigOrig fecOrigConfig;		///< 原始图像模式
		VideoInFecConfigPTZ1R fecPtz1RConfig;	///< 虚拟云台1个感兴趣区域展开模式
		VideoInFecConfigPTZ4R fecPtz4RConfig;	///< 虚拟云台4个感兴趣区域展开模式
		VideoInFecConfig1P2R fec1P2RConfig;		///< 虚拟云台2个感兴趣区域及1个180度展开模式
		VideoInFecConfig1O3R fec1O3RConfig;		///< 虚拟云台3个感兴趣区域展开及1个原始图像模式
		VideoInFecConfigP180 fecP180Config;		///< 180度展开模式
		VideoInFecConfigP360 fecP360Config;		///< 360度展开模式
		int placeholder[32];
	}config;

	int reserve[20];			///< 保留
}VideoInFecInfo;

///< 电子云台控制命令
typedef enum VideoInPtzCmd
{
	VIDEOIN_PTZ_GETCAPS,					///< 获取电子云台控制能力
	VIDEOIN_PTZ_ZOOM,						///< 配置电子云台放大倍数				  
	VIDEOIN_PTZ_FOCUS,						///< 配置电子云台焦距
	VIDEOIN_PTZ_MOVE,						///< 移动电子云台视角
	VIDEOIN_PTZ_LOCATION,					///< 获取电子云台当前绝对位置
	VIDEOIN_PTZ_SPEED						///< 获取电子云台速度范围
}VideoInPtzCmd;

///< 电子云台功能
typedef struct VideoInPtzCaps
{
	unsigned int capsMask;					///< 支持的电子云台控制命令掩码，定义见 VideoInPtzCmd
}VideoInPtzCaps;

///< 电子云台总的移动范围: x轴: 0~8192, y轴: 0~8192
typedef struct VideoInPtzMove
{
	int xCoord;								///< 水平坐标，取值范围0~8192
	int yCoord;								///< 竖直坐标，取值范围0~8192
	int Speed;								///< 速度，取值范围
}VideoInPtzMove;

///< 电子云台移动速度: 最大速度: MaxSpeed,最小速度: MinSpeed
typedef struct VieoInPtzSpeed
{
	int MaxSpeed;							///< 最大速度
	int MinSpeed;							///< 最小速度
}VideoInPtzSpeed;

/// 电子云台配置参数，96字节
typedef struct VideoInPtzPrm
{
	int ptzCmd;								///< 电子云台控制命令, 定义见VideoInPtzCmd

	union
	{
		VideoInPtzCaps ptzCaps;				///< VIDEOIN_PTZ_GETCAPS命令返回值，
		float zoom;							///< VIDEOIN_PTZ_ZOOM命令参数，配置放大倍数，0~1
		float focal;						///< VIDEOIN_PTZ_FOCUS命令参数，配置焦距，0~1
		VideoInPtzMove ptzMove;				///< VIDEOIN_PTZ_MOVE命令参数
		VideoInPtzMove ptzLocation;			///< VIDEOIN_PTZ_LOCATION命令参数
		VideoInPtzSpeed ptzSpeed;			///< VIDEOIN_PTZ_SPEED命令参数
		int reserved[64];
	};

	int reserve[31];						///< 保留
}VideoInPtzPrm;

/// 数字防抖配置参数，64字节
typedef struct VideoInDisPrm
{
	uchar enable;							///< 1:打开    0:关闭
	uchar resed1[3];
	int reserve[15];						///< 保留
}VideoInDisPrm;

typedef struct VideoInCropCfg
{
    int enable;
    Rect_ext rect;
} VideoInCropCfg;

typedef struct VideoInRoiCfg
{
    int enable;
    int iRoiNum;
    Rect_ext rect[8];
    int iMirror;  /* x */
    int iFlip;    /* y */
    int reserve[14];
} VideoInRoiCfg;

/// 视频输入接口，128个指针
typedef struct VideoInput
{
	/// 底层私有数据
	void *priv;


	/// 增加接口引用
	int (*addRef)(struct VideoInput *thiz);


	/// 释放接口
	int (*release)(struct VideoInput *thiz);


	/// 得到视频输入支持的特性。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [In] caps 指向视频输入特性结构VideoInCaps的指针。
	/// \retval 0  获取成功。
	/// \retval <0  获取失败。
	int (*getCaps)(struct VideoInput *thiz, VideoInCaps * caps);


	/// 设置视频输入的视野，分辨率，帧率等格式
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] format 视频输入格式结构指针。
	int (*setFormat)(struct VideoInput *thiz, VideoInFormat *format);


	/// 触发视频输入抓拍，抓拍的原始帧数据将会加上mark标志，用来区分抓拍帧和普通
	/// 帧，以及区分不同的抓拍帧。每次调用最多可以产生一个带标志帧的帧，也就是
	/// 函数调用后紧接着的一帧。此函数可以设计成强制产生新的VD信号，立即从头开始
	/// 采集新的一帧，将正在采集的帧丢弃，来保证触发响应的时效性。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] snapshot 视频输入抓拍结构指针，是一个数组。
	/// \param [in] lanes 一次需要抓拍的车道或通道个数
	/// \retval 0  设置成功。
	/// \retval <0  设置失败。
	int (*snapshot)(struct VideoInput *thiz, VideoInSnapshot * snapshot, int lanes);


	/// 设置视频输入的颜色参数。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] color 指向颜色结构VideoColor的指针。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setColor)(struct VideoInput *thiz, VideoColor *color);


	/// 叠加视频输入的标题参数。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] title 指向标题结构VideoTitle的指针，参数里的坐标是缩放后的坐标。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setTitle)(struct VideoInput *thiz, VideoTitle *title);


	/// 设置视频输入覆盖区域。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] cover 指向视频覆盖结构VideoCover的指针，参数里的坐标是缩放前的坐标。
	/// \retval 0  设置成功。
	/// \retval <0  设置失败。
	int (*setCover)(struct VideoInput *thiz, VideoCover *cover);


	/// 设置视频输入的背景颜色，当没有视频信号时，应该显示为背景颜色。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] color 要设置的颜色。
	/// \retval =0  操作成功。
	/// \retval <0	UNIX标准错误码的负数。
	int (*setBackgroundColor)(struct VideoInput *thiz, Color *color);


	/// 设置视频输入制式。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] standard 视频制式，取VideoStandard类型的值。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setStandard)(struct VideoInput *thiz, int standard);	


	/// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option 指向视频选项结构VideoInOption的指针。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setOptions)(struct VideoInput *thiz, VideoInOptions *option);	


	/// 使能自动光圈
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] enable 使能开关，1-使能，0-禁止
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*enableAutoIris)(struct VideoInput *thiz, int enable);	


	/// 手动调节光圈，如果自动光圈已经打开，手动调节无效
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] open 1-光圈扩大，0-光圈缩小
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*adjustIris)(struct VideoInput *thiz, int open);	


	/// 获取曝光速度列表
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] standard 视频制式，取VideoStandard类型的值。
	/// \param [out] speeds 速度数组，每一种速度用一个float表示，从0递增以曝光等级
	///         作为下标，表示对应等级的具体曝光速度。数组长度必须足以放下所有等级
	///         的速度值，等级数参见getCaps接口。正数表示曝光时间，毫秒为单位。
	///			比如2000表示曝光时间为2秒，是慢速曝光；100表示曝光时间为100ms，
	///         是快速曝光；0表示自动曝光，在数组中下标一定为0(自动曝光等级)。
	/// \param [out] num 表示speeds速度数组所包含的元素个数
	/// \retval 0  获取成功
	/// \retval <0  获取失败
	int (*getExposureSpeeds)(struct VideoInput *thiz, VideoStandard standard, float* speeds, int* num);	
	
	/// 获取前端支持的格式列表，应用层必须从支持的列表中选择一项作为setFormat接口的输入参数。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] standard 视频制式，取VideoStandard类型的值。
	/// \param [out] formats 格式结构VideoInFormat数组，数组长度必须足以放下
	///         所有支持的格式列表。支持的格式数目用VideoInCaps::formatCount表示。
	///			VideoInFormat中的width、height、fps表示前端对应的分辨率下的最大帧率。
	///			VideoInFormat中的window对应分辨率的视野限制，如果4个值都非0，表示固定视野；
	///         如果4个值都为0，表示支持电子云台，视野由应用程序任意控制；4个值都为0也可以
	///			表示底层不关心视野区域，并忽略setFormat接口调用中的VideoInFormat结构该成员。
	/// \retval 0  获取成功
	/// \retval <0  获取失败
	int (*getFormatCaps)(struct VideoInput *thiz, VideoStandard standard, VideoInFormat* formats);	

	/// 重启前端。上层检测到前端异常时，重启前端，恢复异常。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \retval 0  重启成功
	/// \retval <0  重启失败
	int (*reset)(struct VideoInput *thiz);	

	/// 获取视频输入状态
	///
	/// \param [in] shiz 视频输入接口指针
	/// \param [out] status 视频输入预处理状态结构体指针
	/// \retval 0 获取成功
	/// \retval <0 获取失败
	int (*getStatus)(struct VideoInput *thiz, VideoInStatus *status);	
	
	/// 设置视频输入采集模式。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] mode 视频输入采集模式
	/// \retval 0  重启成功
	/// \retval <0  重启失败
	int (*setMode)(struct VideoInput *thiz, VideoInMode mode);	

	
	/// 设置视频输入传感器型号。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] type 视频输入传感器型号字符串，如"Dahua","Hitachi"等等
	/// \retval 0  重启成功
	/// \retval <0  重启失败
	int (*setSensorType)(struct VideoInput *thiz, const char* type);	

	
	/// 设置视频输入颜色调节区域
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] number调节区域个数
	/// \param [in] enhanceArea 调节区域结构体指针
	/// \retval 0 设置成功
	/// \retval <0 设置失败
	int(*setColorAdjustArea)(struct VideoInput *thiz, int number, VideoInColorAdjustArea* area);

	/// 设置视频输入测光模式
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] metering 视频输入测光结构体指针
	/// \retval 0 设置成功
	/// \retval <0 设置失败
	int (*setMeteringMode)(struct VideoInput *thiz, VideoInMeteringMode *mode);
		
	/// 设置视频输入预处理选项
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] options 视频输入预处理选项结构体指针
	/// \retval 0 设置成功
	/// \retval <0 设置失败
	int (*setPreviewOptions)(struct VideoInput *thiz, VideoInPreviewOptions *options);

	/// 设备重启前通知底层保存预处理参数，该部分参数由底层维护应用程序不可见
	///
	/// \param [in] thiz 视频输入接口指针
	/// \retval 0 成功
	/// \retval <0失败
	int (*savePreviewOptions)(struct VideoInput *thiz);


	/// 设置聚焦模式
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] mode 聚焦模式，0-关闭，1-辅助，2-自动
	/// \param [in] options 聚焦算法选项结构体指针
	/// \retval 0 成功
	/// \retval <0失败
	int (*setFocusMode)(struct VideoInput *thiz, int mode, VideoInFocusOptions* options);


	/// 取聚焦状态，辅助聚焦模式下有效
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [out] status 聚焦算法选项结构体指针
	/// \retval 0 成功
	/// \retval <0失败
	int (*getFocusStatus)(struct VideoInput *thiz, VideoInFocusStatus* status);


	/// 聚焦调节，调节放大倍率和焦点
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] focus 相对焦点变化，归一化到-1~1
	/// \param [in] zoom 相对变倍率，归一化到-1~1
	/// \retval 0 成功
	/// \retval <0失败
	int (*adjustFocus)(struct VideoInput *thiz, float focus, float zoom);


	/// 自动聚焦，调节焦点至最佳位置
	///
	/// \param [in] thiz 视频输入接口指针
	/// \retval 0 成功
	/// \retval <0失败
	int (*autoFocus)(struct VideoInput *thiz);


	/// 叠加视频辅助线
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] line 视频辅助线指针，参数里的坐标归一化到 [0,8192)
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setWidgetLine)(struct VideoInput *thiz, VideoWidgetLine *line);	


	/// 持续聚焦调节，调节放大倍率和焦点
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] focus 相对焦点变化速率，归一化到-1~1
	/// \param [in] zoom 相对变倍率速率，归一化到-1~1
	/// \retval 0 成功
	/// \retval <0失败
	int (*adjustFocusContinuously)(struct VideoInput *thiz, float focus, float zoom);


	/// 设置视频输入传感器参数。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] options 视频输入传感器参数
	/// \retval 0  成功
	/// \retval <0  失败
	int (*setSensorOptions)(struct VideoInput *thiz, VideoInSensorOptions* options);


	///设置视屏输入采集模式
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] mode 视屏输入采集模式,0表示普通模式，1表示直通模式
	/// \retval 0  成功
	/// \retval <0  失败        
	int (*setMonitorMode)(struct VideoInput *thiz, int mode);
	
	///设置降噪参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] denoise 降噪参数结构体
	/// \retval 0  成功
	/// \retval <0  失败
	int (*setDenoise)(struct VideoInput *thiz, const VideoInDenoise *denoise);


	///设置降噪内部参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] cfg 降噪参数数组描述
	/// \param [in] cfgDataArr降噪参数数组
	/// \param [in] numbers降噪参数数组个数
	/// \retval 0  成功
	/// \retval <0  失败
	int (*setDenoiseParamsMaps)(struct VideoInput *thiz, const VideoInDenoiseParamsDesc *desc, const VideoInDenoiseParams *cfgDataArr, int numbers);

	///设置减光晕参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] killHallo 减光晕参数数组
	/// \param [in] count 减光晕参数数组个数	
	/// \retval 0  成功
	/// \retval <0  失败
	int (*setKillHalo)(struct VideoInput *thiz, VideoInKillHalo *killHallo, int count);

	///设置外同步相位控制参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] SyncPhase 外同步相位控制参数数组	
	/// \retval 0  成功
	/// \retval <0  失败
	int (*setSyncPhase)(struct VideoInput *thiz, VideoInSyncPhase *SyncPhase);

	/// 获取视频采集输入状态
	///
	/// \param [in] shiz 视频输入接口指针
	/// \param [out] status 采集输入状态结构体指针
	/// \retval 0 获取成功
	/// \retval <0 获取失败
	int (*getVideoInPutStatus)(struct VideoInput *thiz, VideoInPutStatus *status);	

	/// 得到视频输入支持的扩展特性。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [In] caps 指向视频输入特性结构VideoInCapsEx的指针。
	/// \retval 0  获取成功。
	/// \retval <0  获取失败。
	int (*getCapsEx)(struct VideoInput *thiz, VideoInCapsEx * caps);

	/// 设置红灯涂红
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [In] videoRedLight 指向视频输入特性结构VideoInRedLightAdjust的指针。
	/// \param [In] count VideoInRedLightAdjust个数。
	/// \retval 0  获取成功。
	/// \retval <0  获取失败。
	int (*setRedLightAdjust)(struct VideoInput *thiz, const VideoInRedLightAdjust *videoRedLight, int count);

	///设置白平衡参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] whiteBalance白平衡参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setWhiteBalance)(struct VideoInput *thiz, const VideoInWhiteBalance *whiteBalance);

	///设置曝光参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] exposure曝光参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setExposure)(struct VideoInput *thiz, const VideoInExposure *exposure);

	///设置彩转黑参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] dayNight彩转黑参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setDayNight)(struct VideoInput *thiz, const VideoInDayNight * dayNight);
	
	///设置聚焦参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] focus聚焦参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setFocus)(struct VideoInput *thiz, const VideoInFocus * focus);

	///设置变倍参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] zoom变倍参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setZoom)(struct VideoInput *thiz, const VideoInZoom * zoom);

	///设置锐度参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] sharpness锐度参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setSharpness)(struct VideoInput *thiz, const VideoInSharpness * sharpness);

	///设置图像颜色参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] color图像颜色参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setVideoInColor)(struct VideoInput *thiz, const VideoInColor * color);

	///设置图像旋转参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] color图像旋转参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setRotate)(struct VideoInput *thiz, const VideoInRotate * rotate);

	/// 根据特征属性，获取前端支持的格式列表扩展接口。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option 获取前端分辨率的特征属性，参见VideoInFormatOptions类型。
	/// \param [out] formats 格式结构VideoInFormat数组，数组长度必须足以放下
	///         所有支持的格式列表。支持的格式数目用VideoInCaps::formatCount表示。
	///			VideoInFormat中的width、height、fps表示前端对应的分辨率下的最大帧率。
	///			VideoInFormat中的window对应分辨率的视野限制，如果4个值都非0，表示固定视野；
	///         如果4个值都为0，表示支持电子云台，视野由应用程序任意控制；4个值都为0也可以
	///			表示底层不关心视野区域，并忽略setFormat接口调用中的VideoInFormat结构该成员。
	/// \retval 0  获取成功
	/// \retval <0  获取失败
	int (*getFormatCapsEx)(struct VideoInput *thiz, const VideoInFormatOptions *options, VideoInFormat* formats);

	///设置smartIr参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] smartIrParam smartIr参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*setSmartIr)(struct VideoInput *thiz, const VideoInSmartIrParams * smartIrPrm);

	/// 设置自动光圈参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] autoIrisPrm 自动光圈参数结构体
	/// \retval 0 成功
	///	\retval < 0 失败
	int (*setAutoIris)(struct VideoInput *thiz, const VideoInAutoIrisParams *autoIrisPrm);

	/// 设置畸变矫正参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] ldcPrm 畸变矫正参数结构体
	/// \retval 0 成功
	///	\retval < 0 失败
	int (*setLDC)(struct VideoInput *thiz, const VideoInLDCParams *ldcPrm);

	/// 设置感光值
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] ldrPrm 感光值参数结构体
	/// \retval 0 成功
	///	\retval < 0 失败
	int (*setLdr)(struct VideoInput *thiz, const VideoInLdrParams *ldrPrm);

	/// 设置鱼眼矫正参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] fecInfo 视频输入鱼眼矫正信息
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setFec)(struct VideoInput *thiz, VideoInFecInfo *fecInfo);

	/// 控制电子云台
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] ptzPrm 电子云台控制参数
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*ctrltPtz)(struct VideoInput *thiz, VideoInPtzPrm *ptzPrm);

	/// 获取聚焦限位列表
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [out] distance 距离数组，每一种距离用一个uint表示，单位：毫米
	///			     0表示无穷远
	/// \param [out] num 表示distance数组所包含的元素个数
	/// \retval 0  获取成功
	/// \retval <0  获取失败
	int (*getFocusLimit)(struct VideoInput *thiz, uint* distance, int* num);

	/// 设置光圈参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] irisPrm 光圈参数结构体
	/// \retval 0 成功
	///	\retval < 0 失败
	int (*setIris)(struct VideoInput *thiz, const VideoInIrisParams *irisPrm);

	/// 设置数字防抖参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] disPrm 数字防抖参数结构体
	/// \retval 0 成功
	///	\retval < 0 失败
	int (*setDis)(struct VideoInput *thiz, const VideoInDisPrm *disPrm);

	///设置图像颜色参数
	///
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] color图像颜色参数结构体
	/// \retval 0  成功
	/// \retval < 0  失败
	int (*getColor)(struct VideoInput *thiz, const VideoColor *color);

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option 指向视频选项结构VideoInOption的指针。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*getOptions)(struct VideoInput *thiz, VideoInOptions *option);	

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option Vi视频流使能开关。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*enableViStream)(struct VideoInput *thiz, int enables);

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option Vi模块设置crop值。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setViCrop)(struct VideoInput *thiz, VideoInCropCfg* pCropCfg);

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option Vi模块获取crop值。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*getViCrop)(struct VideoInput *thiz, VideoInCropCfg* pCropCfg);

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option 设置画中画的状态。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setPipStatus)(struct VideoInput *thiz, int enables);

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option 设置模式切换类型。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setAiMode)(struct VideoInput *thiz, int iAimode);

    /// 设置视频输入选项。
	/// 
	/// \param [in] thiz 视频输入接口指针
	/// \param [in] option 画中画设置ROI画框属性。
	/// \retval 0  设置成功
	/// \retval <0  设置失败
	int (*setPipRoiCfg)(struct VideoInput *thiz, VideoInRoiCfg* pstRoiCfg);

	///< 保留字节
	void* reserved[63];

} VideoInput;


/// 得到视频输入通道的个数
int PAL_API getVideoInputChannels(void);


/// 得到视频输入支持的制式标准
/// 
/// \param [out] mask 视频输入制式掩码指针，取 VideoStandard 的位掩码
/// \retval 0  成功
/// \retval <0  失败
int PAL_API getVideoInputStandardMask(int* mask);


/// 视频输入接口描述，128字节
typedef struct VideoInDesc
{
	int				channel;		///< 视频输入物理通道号
	VideoStandard	standard;		///< 视频制式
	VideoSurface	*surface;		///< 视频输入对应的表面
	int 			card;			///< 子卡槽位号，0表示主板，>0表示子卡
	int				connectionId;	///< 级联连接ID
	int				reserved[27];	///< 保留
} VideoInDesc;


/// 创建视频输入接口
///
/// \param [in] desc 视频输入接口描述结构VideoInDesc指针
/// \param [out] videoInput 视频输入接口指针的指针
/// \retval <0 创建失败
/// \retval 0 创建成功
int PAL_API createVideoInput(VideoInDesc *desc, VideoInput **videoInput);

/// 视频输入模式
typedef enum
{
    VIDEOIN_ORIGINAL = 0,       ///<一路通道，原始输入
	VIDEOIN_P360,               ///<一路通道，全景展开输入
	VIDEOIN_4PTZ,               ///<四路通道，4个图像分割ptz
	VIDEOIN_P180,               ///<一路通道，180°展开
	VIDEOIN_ORIGINAL_3PTZ,      ///<四路通道，原始+ 3ptz
	VIDEOIN_ORIGINAL_P180_3PTZ, ///<五路通道，原始+ 180°+ 3ptz
	VIDEOIN_ORIGINAL_P180_4PTZ  ///<六路通道，原始+ 180°+ 4ptz
} VideoInputMode;

/// 设置视频输入码流模式，确定模拟的视频输入通道数
/// 
/// \param [int] mode 视频输入模式
/// \retval 0  成功
/// \retval <0  失败
int PAL_API setVideoInputMode(VideoInputMode mode);

/// @} end of group

#ifdef __cplusplus
}
#endif

#endif //__VIDEO_IN_API_H__

